home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2002 #3 / Amiga Plus CD - 2002 - No. 03.iso / AmigaPlus / Tools / Development / renderlib40 / src / rnd_memory.c < prev    next >
Encoding:
C/C++ Source or Header  |  2003-01-12  |  4.8 KB  |  269 lines
  1.  
  2. #include "lib_init.h"
  3. #include "lib_debug.h"
  4. #include <render/render.h>
  5. #include <proto/utility.h>
  6. #include <proto/exec.h>
  7.  
  8. LIBAPI void memfill32(ULONG *d, ULONG len, ULONG fill)
  9. {
  10.     ULONG len8;
  11.     len >>= 2;
  12.     len8 = (len >> 3) + 1;
  13.     switch (len & 7)
  14.     {
  15.         do
  16.         {
  17.                     *d++ = fill;
  18.             case 7:    *d++ = fill;
  19.             case 6:    *d++ = fill;
  20.             case 5:    *d++ = fill;
  21.             case 4:    *d++ = fill;
  22.             case 3:    *d++ = fill;
  23.             case 2:    *d++ = fill;
  24.             case 1:    *d++ = fill;
  25.             case 0:    len8--;
  26.  
  27.         } while (len8);
  28.     }
  29. }
  30.  
  31. LIBAPI void memfill8(UBYTE *d, ULONG len, UBYTE fill)
  32. {
  33.     ULONG len8;
  34.     len8 = (len >> 3) + 1;
  35.     switch (len & 7)
  36.     {
  37.         do
  38.         {
  39.                     *d++ = fill;
  40.             case 7:    *d++ = fill;
  41.             case 6:    *d++ = fill;
  42.             case 5:    *d++ = fill;
  43.             case 4:    *d++ = fill;
  44.             case 3:    *d++ = fill;
  45.             case 2:    *d++ = fill;
  46.             case 1:    *d++ = fill;
  47.             case 0:    len8--;
  48.  
  49.         } while (len8);
  50.     }
  51. }
  52.  
  53. static void memcpy8reverse(UBYTE *s, UBYTE *d, ULONG len)
  54. {
  55.     ULONG len8;
  56.     s += len;
  57.     d += len;
  58.     len8 = (len >> 3) + 1;
  59.     switch (len & 7)
  60.     {
  61.         do
  62.         {
  63.                     *--d = *--s;
  64.             case 7:    *--d = *--s;
  65.             case 6:    *--d = *--s;
  66.             case 5:    *--d = *--s;
  67.             case 4:    *--d = *--s;
  68.             case 3:    *--d = *--s;
  69.             case 2:    *--d = *--s;
  70.             case 1:    *--d = *--s;
  71.             case 0:    len8--;
  72.  
  73.         } while (len8);
  74.     }
  75. }
  76.  
  77.  
  78. static APTR public_alloc(RNDMH *rmh, LONG size)
  79. {
  80.     return AllocMem(size, rmh->memflags);
  81. }
  82.  
  83. static void public_free(RNDMH *rmh, APTR mem, LONG size)
  84. {
  85.     FreeMem(mem, size);
  86. }
  87.  
  88. static APTR priv_alloc(RNDMH *rmh, LONG size)
  89. {
  90.     APTR mem;
  91.     ObtainSemaphore(&rmh->lock);
  92.     mem = Allocate(&rmh->mh, size);
  93.     ReleaseSemaphore(&rmh->lock);
  94.     return mem;
  95. }
  96.  
  97. static void priv_free(RNDMH *rmh, APTR mem, LONG size)
  98. {
  99.     ObtainSemaphore(&rmh->lock);
  100.     Deallocate(&rmh->mh, mem, size);
  101.     ReleaseSemaphore(&rmh->lock);
  102. }
  103.  
  104. static APTR pool_alloc(RNDMH *rmh, LONG size)
  105. {
  106.     APTR mem;
  107.     ObtainSemaphore(&rmh->lock);
  108.     mem = AllocPooled(rmh->object, size);
  109.     ReleaseSemaphore(&rmh->lock);
  110.     return mem;
  111. }
  112.  
  113. static void pool_free(RNDMH *rmh, APTR mem, LONG size)
  114. {
  115.     ObtainSemaphore(&rmh->lock);
  116.     FreePooled(rmh->object, mem, size);
  117.     ReleaseSemaphore(&rmh->lock);
  118. }
  119.  
  120. LIBAPI RNDMH *CreateRMHandlerA(struct TagItem *tags)
  121. {
  122.     RNDMH *rmh = AllocMem(sizeof(RNDMH), MEMF_ANY);
  123.     if (!rmh) return NULL;
  124.     
  125.     rmh->type = GetTagData(RND_MemType, RMHTYPE_PUBLIC, tags);
  126.     switch (rmh->type)
  127.     {
  128.         default:
  129.             goto fail;
  130.     
  131.         case RMHTYPE_POOL:
  132.             rmh->memflags = GetTagData(RND_MemFlags, MEMF_ANY, tags);                        
  133.             rmh->object = CreatePool(rmh->memflags, 16384, 2048);
  134.             if (!rmh->object) goto fail;
  135.             rmh->alloc = pool_alloc;
  136.             rmh->free = pool_free;
  137.             InitSemaphore(&rmh->lock);
  138.             return rmh;
  139.                     
  140.         case RMHTYPE_PUBLIC:
  141.             rmh->memflags = GetTagData(RND_MemFlags, MEMF_ANY, tags);
  142.             rmh->alloc = public_alloc;
  143.             rmh->free = public_free;
  144.             return rmh;
  145.  
  146.         case RMHTYPE_PRIVATE:
  147.         {    
  148.             struct MemChunk *mc = (struct MemChunk *) GetTagData(RND_MemBlock, NULL, tags);
  149.             ULONG size = GetTagData(RND_MemSize, 0, tags);
  150.             if (!mc || !size) goto fail;
  151.             rmh->mh.mh_Node.ln_Type = NT_MEMORY;
  152.             rmh->mh.mh_Node.ln_Name = NULL;
  153.             rmh->mh.mh_First = mc;
  154.             rmh->mh.mh_Lower = (APTR) mc;
  155.             rmh->mh.mh_Upper = (APTR) ((ULONG) mc + size);
  156.             rmh->mh.mh_Free = size;
  157.             mc->mc_Next = NULL;
  158.             mc->mc_Bytes = size;
  159.             rmh->alloc = priv_alloc;
  160.             rmh->free = priv_free;
  161.             memfill8((UBYTE *) &rmh->lock, sizeof(struct SignalSemaphore), 0);
  162.             InitSemaphore(&rmh->lock);
  163.             return rmh;
  164.         }
  165.     }
  166.  
  167. fail:
  168.  
  169.     FreeMem(rmh, sizeof(RNDMH));
  170.     return NULL;
  171. }
  172.  
  173. LIBAPI void DeleteRMHandler(RNDMH *rmh)
  174. {
  175.     if (!rmh) return;
  176.     if (rmh->type == RMHTYPE_POOL)
  177.     {
  178.         DeletePool(rmh->object);
  179.     }
  180.     FreeMem(rmh, sizeof(RNDMH));
  181. }
  182.  
  183. LIBAPI APTR AllocRenderMem(RNDMH *rmh, ULONG size)
  184. {
  185.     if (rmh) return (*rmh->alloc)(rmh, size);
  186.     return AllocMem(size, MEMF_ANY);
  187. }
  188.  
  189. LIBAPI void FreeRenderMem(RNDMH *rmh, APTR mem, ULONG size)
  190. {
  191.     if (rmh)
  192.     {
  193.         (*rmh->free)(rmh, mem, size);
  194.     }
  195.     else
  196.     {
  197.         FreeMem(mem, size);
  198.     }
  199. }
  200.  
  201. LIBAPI APTR AllocRenderVec(RNDMH *rmh, ULONG size)
  202. {
  203.     ULONG *mem;
  204.     size += 8;
  205.     mem = AllocRenderMem(rmh, size);
  206.     if (mem)
  207.     {
  208.         *mem++ = (ULONG) rmh;
  209.         *mem++ = size;
  210.     }
  211.     return mem;
  212. }
  213.  
  214. LIBAPI void FreeRenderVec(ULONG *mem)
  215. {
  216.     if (mem)
  217.     {
  218.         ULONG size = *--mem;
  219.         RNDMH *rmh = (RNDMH *) *--mem;
  220.         FreeRenderMem(rmh, mem, size);
  221.     }
  222. }
  223.  
  224. LIBAPI APTR AllocRenderVecClear(APTR rmh, ULONG size)
  225. {
  226.     ULONG *mem;
  227.     size = (size + 3) & ~3;
  228.     mem = AllocRenderVec(rmh, size);
  229.     if (mem)
  230.     {
  231.         memfill32(mem, size, 0);
  232.     }
  233.     return mem;
  234. }
  235.  
  236.  
  237. LIBAPI void TurboFillMem(APTR dst, ULONG len, ULONG v)
  238. {
  239.     if (((((ULONG) dst) & 3) == 0) && ((len & 3) == 0))
  240.     {    
  241.         v &= 0xff;
  242.         v = (v<<8) | v;
  243.         v = (v<<16) | v;
  244.         memfill32(dst, len, v);
  245.     }
  246.     else
  247.     {
  248.         memfill8((UBYTE *) dst, len, (UBYTE) v);
  249.     }
  250. }
  251.  
  252.  
  253. LIBAPI void TurboCopyMem(APTR src, APTR dst, ULONG len)
  254. {
  255.     if (((ULONG) dst > (ULONG) src) && ((ULONG) dst < (ULONG) src + len))
  256.     {
  257.         memcpy8reverse((UBYTE *) src, (UBYTE *) dst, len);
  258.         return;
  259.     }
  260.  
  261.     if ((((ULONG) src) & 3) || (((ULONG) dst) & 3) || len & 3)
  262.     {
  263.         CopyMem(src, dst, len);
  264.         return;
  265.     }
  266.  
  267.     CopyMemQuick(src, dst, len);
  268. }
  269.